
import cv2
import numpy as np
from PIL import Image
import requests
from io import BytesIO
import matplotlib.pyplot as plt

url = 'https://i.imgur.com/1vzDG2J.jpg'
def _downloadImage(url):
  resp = requests.get(url)
  img = np.asarray(bytearray(resp.content), dtype="uint8")
  img = cv2.imdecode(img, cv2.IMREAD_COLOR)
  return img
  
img = _downloadImage(url)
print('origin image shape: {}'.format(img.shape))

# Scale image bằng cách gấp đôi width and height
h, w = img.shape[:2]
imgScale = cv2.resize(img, (int(w*2), int(h*2)), interpolation = cv2.INTER_LINEAR)
print('scale image shape: {}'.format(imgScale.shape))

fig = plt.figure(figsize=(10, 7))
rows = 2
columns = 2
fig.add_subplot(rows, columns, 1)
plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB)),plt.title('Origin Image')
fig.add_subplot(rows, columns, 2)
plt.subplot(122),plt.imshow(cv2.cvtColor(imgScale, cv2.COLOR_BGR2RGB)),plt.title('Scale Image')

origin image shape: (709, 621, 3)
scale image shape: (1418, 1242, 3)

(<AxesSubplot:title={'center':'Scale Image'}>,
 <matplotlib.image.AxesImage at 0x20aa7578310>,
 Text(0.5, 1.0, 'Scale Image'))


rows, cols = img.shape[:2]
# Dịch chuyển hình ảnh xuống góc dưới bên phải
tx, ty = (200, 200)
M1 = np.array([[1, 0, tx], 
              [0, 1, ty]], dtype=np.float32)
tran1 = cv2.warpAffine(img, M1, (cols, rows))

# Dịch chuyển hình ảnh xuống góc dưới bên trái
M2 = np.array([[1, 0, -tx], 
              [0, 1, ty]], dtype=np.float32)
tran2 = cv2.warpAffine(img, M2, (cols, rows))

# Dịch chuyển hình ảnh xuống góc dưới bên trái
M3 = np.array([[1, 0, tx], 
              [0, 1, -ty]], dtype=np.float32)
tran3 = cv2.warpAffine(img, M3, (cols, rows))

# Dịch chuyển hình ảnh xuống góc dưới bên trái
M4 = np.array([[1, 0, -tx], 
              [0, 1, -ty]], dtype=np.float32)
tran4 = cv2.warpAffine(img, M4, (cols, rows))

plt.figure(figsize=(16, 4))
plt.subplot(151),plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB)),plt.title('Origin Image')
plt.subplot(152),plt.imshow(cv2.cvtColor(tran1, cv2.COLOR_BGR2RGB)),plt.title('Translate to Bottom Right')
plt.subplot(153),plt.imshow(cv2.cvtColor(tran2, cv2.COLOR_BGR2RGB)),plt.title('Translate to Bottom Left')
plt.subplot(154),plt.imshow(cv2.cvtColor(tran3, cv2.COLOR_BGR2RGB)),plt.title('Translate to Up Right')
plt.subplot(155),plt.imshow(cv2.cvtColor(tran4, cv2.COLOR_BGR2RGB)),plt.title('Translate to Up Left')

(<AxesSubplot:title={'center':'Translate to Up Left'}>,
 <matplotlib.image.AxesImage at 0x26166bbb1c0>,
 Text(0.5, 1.0, 'Translate to Up Left'))


# Xoay ảnh kích thước 45 độ tại tâm của ảnh, độ phóng đại ảnh không đổi.
M5 = cv2.getRotationMatrix2D(center = (cols/2,rows/2), angle=-45, scale=1)
tran5 = cv2.warpAffine(img, M5, (cols,rows))

# Xoay ảnh kích thước 45 độ tại tâm của ảnh và độ phóng đại giảm 1/2
M6 = cv2.getRotationMatrix2D(center = (cols/2,rows/2), angle=-45, scale=0.5)
tran6 = cv2.warpAffine(img, M6, (cols,rows))

# Xoay ảnh kích thước -45 độ tại tâm của ảnh
M7 = cv2.getRotationMatrix2D(center = (cols/2,rows/2), angle=45, scale=1)
tran7 = cv2.warpAffine(img, M7, (cols,rows))

# Xoay ảnh kích thước 20 độ tại góc trên bên trái
M8 = cv2.getRotationMatrix2D(center = (0, 0), angle=-20, scale=1)
tran8 = cv2.warpAffine(img, M8, (cols,rows))

# Xoay ảnh kích thước 20 độ tại góc dưới bên phải
M9 = cv2.getRotationMatrix2D(center = (cols,rows), angle=-20, scale=1)
tran9 = cv2.warpAffine(img, M9, (cols,rows))

plt.figure(figsize=(12, 8))
plt.subplot(231),plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB)),plt.title('Origin Image')
plt.subplot(232),plt.imshow(cv2.cvtColor(tran5, cv2.COLOR_BGR2RGB)),plt.title('Rotate 45 at centroid')
plt.subplot(233),plt.imshow(cv2.cvtColor(tran6, cv2.COLOR_BGR2RGB)),plt.title('Rotate 45 resize 0.5')
plt.subplot(234),plt.imshow(cv2.cvtColor(tran7, cv2.COLOR_BGR2RGB)),plt.title('Rotate -45 at centroid')
plt.subplot(235),plt.imshow(cv2.cvtColor(tran8, cv2.COLOR_BGR2RGB)),plt.title('Rotate 20 at upper left corner')
plt.subplot(236),plt.imshow(cv2.cvtColor(tran9, cv2.COLOR_BGR2RGB)),plt.title('Rotate 20 at bottom right corner')

(<AxesSubplot:title={'center':'Rotate 20 at bottom right corner'}>,
 <matplotlib.image.AxesImage at 0x261675a8f70>,
 Text(0.5, 1.0, 'Rotate 20 at bottom right corner'))


rows,cols,ch = img.shape

pts1 = np.float32([[50,50], [200,50], [50,200]])
# pts2 = np.float32([[50,100], [200,50], [50,200]])
pts2 = np.float32([[50,300], [200,150], [150, 400]])

M = cv2.getAffineTransform(pts1,pts2)
imageAffine = cv2.warpAffine(img,M,(cols,rows))

# Hiển thị hình ảnh gốc và 3 điểm ban đầu trên ảnh
plt.subplot(121),plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB)),plt.title('Input')
for (x, y) in pts1:
    plt.scatter(x, y, s=50, c='white', marker='x')

# Hiển thị hình ảnh sau dịch chuyển và 3 điểm mục tiêu của phép dịch chuyển.
plt.subplot(122),plt.imshow(cv2.cvtColor(imageAffine, cv2.COLOR_BGR2RGB)),plt.title('Output')
for (x, y) in pts2:
    plt.scatter(x, y, s=50, c='white', marker='x')


pts1 = np.float32([[50,50],[350,50],[50,350],[350,350]])
pts2 = np.float32([[0,0],[200,50],[50,300],[300,300]])

M = cv2.getPerspectiveTransform(pts1,pts2)

dst = cv2.warpPerspective(img,M,(300,300))

plt.subplot(121),plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB)),plt.title('Input')
for (x, y) in pts1:
  plt.scatter(x, y, s=50, c='white', marker='x')
plt.subplot(122),plt.imshow(cv2.cvtColor(dst, cv2.COLOR_BGR2RGB)),plt.title('Perspective Transform')
for (x, y) in pts2:
  plt.scatter(x, y, s=50, c='white', marker='x')
plt.show()


pts1 = np.float32([[50,50],[350,50],[50,350],[350,350]])

M = cv2.getPerspectiveTransform(pts1,pts1)

dst = cv2.warpPerspective(img,M,(300,300))

plt.subplot(121),plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB)),plt.title('Input')
for (x, y) in pts1:
  plt.scatter(x, y, s=50, c='white', marker='x')
plt.subplot(122),plt.imshow(cv2.cvtColor(dst, cv2.COLOR_BGR2RGB)),plt.title('Crop Image')
plt.show()


flip1 = cv2.flip(img, 1)
flip2 = cv2.flip(img, 0)
flip3 = cv2.flip(img, -1)

plt.figure(figsize=(12, 8))
plt.subplot(231),plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB)),plt.title('Origin Image')
plt.subplot(234),plt.imshow(cv2.cvtColor(flip1, cv2.COLOR_BGR2RGB)),plt.title('Flip the image horizontally')
plt.subplot(235),plt.imshow(cv2.cvtColor(flip2, cv2.COLOR_BGR2RGB)),plt.title('Flip the image vertically')
plt.subplot(236),plt.imshow(cv2.cvtColor(flip3, cv2.COLOR_BGR2RGB)),plt.title('Flips the image around both axes')

(<AxesSubplot:title={'center':'Flips the image around both axes'}>,
 <matplotlib.image.AxesImage at 0x20a8f437f10>,
 Text(0.5, 1.0, 'Flips the image around both axes'))


import cv2
import numpy as np
img = cv2.imread("4k.jpeg")[:,:,::-1]
kernel = np.ones((5,5),np.float32)/25
imgSmooth = cv2.filter2D(img,-1,kernel)

fig = plt.figure(figsize=(10, 7))
rows = 1
columns = 2
fig.add_subplot(rows, columns, 1)
plt.imshow(img),plt.title('Original')
plt.xticks([]), plt.yticks([])
fig.add_subplot(rows, columns, 2)
plt.imshow(imgSmooth),plt.title('Averaging')
plt.xticks([]), plt.yticks([])
plt.show()


blur = cv2.blur(img,(5,5))

fig = plt.figure(figsize=(10, 7))
rows = 1
columns = 2
fig.add_subplot(rows, columns, 1)
plt.imshow(img),plt.title('Original')
plt.xticks([]), plt.yticks([])
fig.add_subplot(rows, columns, 2)
plt.imshow(blur),plt.title('Blurred')
plt.xticks([]), plt.yticks([])
plt.show()


gaussian_img = cv2.GaussianBlur(img, (5, 5), 0)
fig = plt.figure(figsize=(10, 7))
rows = 1
columns = 2
fig.add_subplot(rows, columns, 1)
plt.imshow(img),plt.title('Original')
plt.xticks([]), plt.yticks([])
fig.add_subplot(rows, columns, 2)
plt.imshow(gaussian_img),plt.title('Gaussian Blurred')
plt.xticks([]), plt.yticks([])
plt.show()


median_img = cv2.medianBlur(img, 5, 0)
bilateral_img = cv2.bilateralFilter(img, 9, 75, 75)

fig = plt.figure(figsize=(10, 7))
rows = 1
columns = 3
fig.add_subplot(rows, columns, 1)
plt.subplot(131),plt.imshow(img),plt.title('Original')
plt.xticks([]), plt.yticks([])
fig.add_subplot(rows, columns, 2)
plt.subplot(132),plt.imshow(median_img),plt.title('Median Blurred')
plt.xticks([]), plt.yticks([])
fig.add_subplot(rows, columns, 3)
plt.subplot(133),plt.imshow(bilateral_img),plt.title('Bilateral Blurred')
plt.xticks([]), plt.yticks([])
plt.show()


img = cv2.imread("iris.jpg")
plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
plt.show()


# Create kernel
kernel = np.array([[0, -1, 0],
                   [-1, 5,-1],
                   [0, -1, 0]])
# Sharpen image
image_sharp = cv2.filter2D(image, -1, kernel)
# Show image
plt.imshow(cv2.cvtColor(image_sharp, cv2.COLOR_BGR2RGB)), plt.axis("off")
plt.show()


# Load image
image_bgr = cv2.imread("iris.jpg")
# Convert to YUV
image_yuv = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2YUV)
# Apply histogram equalization
image_yuv[:, :, 0] = cv2.equalizeHist(image_yuv[:, :, 0])
# Convert to RGB
image_rgb = cv2.cvtColor(image_yuv, cv2.COLOR_YUV2RGB)
# Show image
fig = plt.figure(figsize=(10, 7))
rows = 1
columns = 2
fig.add_subplot(rows, columns, 2)
plt.imshow(image_rgb), plt.axis("off"),plt.title('Enhancing Contrast')
fig.add_subplot(rows, columns, 1)
plt.imshow(cv2.cvtColor(image_bgr, cv2.COLOR_BGR2RGB)), plt.axis("off"),plt.title('Origin Image')
plt.show()


# Load image as grayscale
image_grey = cv2.imread("main.jpg", cv2.IMREAD_GRAYSCALE)
# Apply adaptive thresholding
max_output_value = 255
neighborhood_size = 999
subtract_from_mean = 10
image_binarized = cv2.adaptiveThreshold(image_grey,max_output_value,cv2.ADAPTIVE_THRESH_GAUSSIAN_C,cv2.THRESH_BINARY,neighborhood_size,subtract_from_mean)
# Show image
plt.imshow(image_binarized, cmap="gray"), plt.axis("off")
plt.show()


# Apply cv2.ADAPTIVE_THRESH_MEAN_C
image_mean_threshold = cv2.adaptiveThreshold(image_grey,
 max_output_value,
cv2.ADAPTIVE_THRESH_MEAN_C,
cv2.THRESH_BINARY,
neighborhood_size,
subtract_from_mean)
# Show image
plt.imshow(image_mean_threshold, cmap="gray"), plt.axis("off")
plt.show()


import PIL.Image
import torch
from torchvision import transforms
img = PIL.Image.open('iris.jpg')
fig, ax = plt.subplots(2, 2, figsize=(16, 10))

# brightness
loader_transform1 = transforms.ColorJitter(brightness=2)
img1 = loader_transform1(img)
ax[0, 0].set_title(f'brightness')
ax[0, 0].imshow(img1)

# contrast
loader_transform2 = transforms.ColorJitter(contrast=2)
img2 = loader_transform2(img)
ax[0, 1].set_title(f'contrast')
ax[0, 1].imshow(img2)

# saturation
loader_transform3 = transforms.ColorJitter(saturation=2)
img3 = loader_transform3(img)
ax[1, 0].set_title(f'saturation')
ax[1, 0].imshow(img3)
fig.savefig('color augmentation', bbox_inches='tight')

# hue
loader_transform4 = transforms.ColorJitter(hue=0.2)
img4 = loader_transform4(img)
ax[1, 1].set_title(f'hue')
ax[1, 1].imshow(img4)

fig.savefig('color augmentation', bbox_inches='tight')


import cv2
import numpy as np
import requests
from matplotlib import pyplot as plt

url = 'https://i.pinimg.com/736x/6d/9c/e0/6d9ce08209b81b28c6ea64012e070003.jpg'
img = _downloadImage(url)

edges = cv2.Canny(img, 100, 200)
plt.subplot(121),plt.imshow(img,cmap = 'gray')
plt.title('Original Image'), plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(edges,cmap = 'gray')
plt.title('Edge Image'), plt.xticks([]), plt.yticks([])

plt.show()


import skimage
def noisy(noise_typ,image):
    if noise_typ == "gauss":
        noisy = skimage.util.random_noise(image, mode='gaussian', seed=None, clip=True)
        return noisy
    elif noise_typ == "s&p":
        row,col = image.shape
        s_vs_p = 0.05
        amount = 0.04
        out = np.copy(image)
        # Salt mode
        num_salt = np.ceil(amount * image.size * s_vs_p)
        coords = [np.random.randint(0, i - 1, int(num_salt))
                for i in image.shape]
        out[coords] = 1

        # Pepper mode
        num_pepper = np.ceil(amount* image.size * (1. - s_vs_p))
        coords = [np.random.randint(0, i - 1, int(num_pepper))
                for i in image.shape]
        out[coords] = 0
        return out
    elif noise_typ == "poisson":
        vals = len(np.unique(image))
        vals = 2 ** np.ceil(np.log2(vals))
        noisy = np.random.poisson(image * vals) / float(vals)
        return noisy


img = cv2.cvtColor(cv2.imread("lena_gray.png"), cv2.COLOR_BGR2GRAY)
gauss_noise = noisy("gauss",img)
sp_noise = noisy("s&p", img)
poisson_noise = noisy("poisson",img)

plt.figure(figsize=(12, 8))
plt.subplot(241),plt.imshow(img, cmap='gray'),plt.title('Origin Image')
plt.xticks([]), plt.yticks([])
plt.subplot(242),plt.imshow(gauss_noise, cmap='gray'),plt.title('Gaussian Noise')
plt.xticks([]), plt.yticks([])
plt.subplot(243),plt.imshow(sp_noise, cmap='gray'),plt.title('Salt & Pepper Noise')
plt.xticks([]), plt.yticks([])
plt.subplot(244),plt.imshow(poisson_noise, cmap='gray'),plt.title('Poisson Noise')
plt.xticks([]), plt.yticks([])

C:\Users\ADMIN\AppData\Local\Temp/ipykernel_11468/115571172.py:22: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.
  out[coords] = 1
C:\Users\ADMIN\AppData\Local\Temp/ipykernel_11468/115571172.py:28: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.
  out[coords] = 0

(([], []), ([], []))


from sklearn.metrics import mean_squared_error
import math
gaussian_img = np.uint8(gauss_noise*255).astype(np.uint8)


dst = cv2.fastNlMeansDenoising(gaussian_img, None, 3, 7, 21)

plt.subplot(121),plt.imshow(gauss_noise, cmap='gray'),plt.title('Noise')
plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(dst, cmap='gray'),plt.title('Denoise')
plt.xticks([]), plt.yticks([])
plt.show()

Tiền xử lý ảnh¶

1. Vai trò của tiền xử lý ảnh¶

2. Tiền xử lý ảnh¶

2.1. Các biến đổi hình học.¶

Định nghĩa:¶

2.1.1. Phóng đại ảnh (Scale ảnh)¶

2.1.2. Dịch chuyển ảnh (Translation)¶

2.1.2. Xoay ảnh (Rotation)¶

2.1.3. Biến đổi Affine¶

2.1.4. Biến đổi phối cảnh (Perspective Transform)¶

2.1.5 Flip¶

2.2. Làm mịn ảnh (smoothing images)¶

2.2.1. Bộ lọc tích chập 2D (2D convolution)¶

2.2.2. Làm mờ ảnh (Image blurring)¶

1. Trung bình (Average)¶

2. Bộ lọc Gausian¶

2.2.3 Sharpening Images¶

2.2.4 Enhancing Contrast¶

2.2.6 Binarizing Images¶

2.3 Color augmentation¶

Brightness¶

Contrast¶

Saturation¶

Hue¶

2.4. Phương pháp Canny phát hiện edge¶

2.5 Denoising¶

2.6 Image Generation¶